/*
 * Esta clase se utilizará como herramienta para el manejo de archivos
 */
package utils;

import java.awt.FileDialog;
import java.awt.Frame;
import java.io.FileInputStream;
import mapeos.Archivo;
import java.awt.image.BufferedImage;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;

/**
 *
 * @author BIPiane
 */
public class ArchUtils {

    private static String[] imagenFormato = {"jpg", "png", "gif", "tif", "tiff", "jpeg"};
    private static String[] audioFormato = {"mp3", "m4a"};
    private static String[] videoFormato = {"avi", "mov", "mpg", "mp4"};
    private static String[] documentoFormato = {"pdf", "doc", "docx", "txt", "rtfd", "java", "sql"};
    private static String[] comprimidoFormato = {"rar", "zip", "tar"};
    private static String[] presentacionFormato = {"pps", "keynote", "sldx"};
    //
    public static String tipoCarpeta = "Carpeta";
    public static String tipoImagen = "Imagen";
    public static String tipoDocumento = "Documento";
    public static String tipoAudio = "Audio";
    public static String tipoVideo = "Video";
    public static String tipoComprimido = "Comprimido";
    public static String tipoPresentacion = "Presentacion";
    public static String tipoOtro = "Otro";
    //
    private static String unixBarra = "\\/";
    private static String windowsBarra = "\\\\";
    private static String puntoExtencion = "\\.";

    public static void main(String[] args) {
        String texto1 = "/Mac/Desktop/PandoraBox-Salidas.txt";
        System.out.println("Ruta: " + texto1);
        System.out.println("Nombre: " + ArchUtils.getNombreArchivo(texto1));
        System.out.println("Extensión: " + ArchUtils.getExtencionArchivo(texto1));
        System.out.println("Tipo: " + ArchUtils.getTipoArchivo(texto1));

        texto1 = "C:\\Windows\\Desktop\\PandoraBox-Salidas.txt";
        System.out.println("\nRuta: " + texto1);
        System.out.println("Nombre: " + ArchUtils.getNombreArchivo(texto1));
        System.out.println("Extensión: " + ArchUtils.getExtencionArchivo(texto1));
        System.out.println("Tipo: " + ArchUtils.getTipoArchivo(texto1));
    }

    /**
     * Obtiene la extensión de un achivo
     *
     * @param arch
     * @return
     */
    public static String getExtencionArchivo(String arch) {
        String extencion = "";
        String[] temp = arch.split(puntoExtencion);
        if (temp.length > 1) {
            extencion = temp[temp.length - 1].toLowerCase();
        }
        return extencion;
    }

    /**
     * Obtiene la el nombre de un achivo sin la extención
     * @param rutaArchivo
     * @return 
     */
    public static String getNombreArchivo(String rutaArchivo) {
        String nombre = "ejemplo";
        if (rutaArchivo.length() > 0) {
            String rutaFormart = "";
            String delimitador = "";
            String fileSystem = System.getProperty("os.name");
            if (fileSystem.equalsIgnoreCase("Mac OS X")) {
                rutaFormart = ArchUtils.rutaWindowsToUnix(rutaArchivo);
                delimitador = unixBarra;
            } else {
                rutaFormart = ArchUtils.rutaUnixToWindows(rutaArchivo);
                delimitador = windowsBarra;
            }
            String[] temp = rutaFormart.split(delimitador);
            String nomExt = temp[temp.length - 1];
            delimitador = "\\.";
            temp = nomExt.split(delimitador);
            nombre = temp[0];
        }
        return nombre;
    }

    /**
     * Transforma una ruta de Windows con "\" a una ruta 
     * UNIX con "/"
     * @param ruta
     * @return
     */
    private static String rutaWindowsToUnix(String ruta) {
        String rutaFormart = "";
        rutaFormart = ruta.replaceAll(windowsBarra, unixBarra);
        return rutaFormart;
    }

    /**
     * Transforma una ruta de UNIX con "/" a una ruta 
     * Windows con "\"
     * @param ruta
     * @return 
     */
    private static String rutaUnixToWindows(String ruta) {
        String rutaFormart = "";
        rutaFormart = ruta.replaceAll(unixBarra, windowsBarra);
        return rutaFormart;
    }

    /**
     * Determina si el formato de una imágen es permitido o valido.
     *
     * @param arch
     * @return
     */
    public static String getTipoArchivo(String archivo) {
        String extencion = ArchUtils.getExtencionArchivo(archivo);
        if (extencion.equalsIgnoreCase("")) {
            return tipoCarpeta;
        } else {
            for (String tipo : imagenFormato) {
                if (extencion.equalsIgnoreCase(tipo)) {
                    return tipoImagen;
                }
            }
            for (String tipo : audioFormato) {
                if (extencion.equalsIgnoreCase(tipo)) {
                    return tipoAudio;
                }
            }
            for (String tipo : videoFormato) {
                if (extencion.equalsIgnoreCase(tipo)) {
                    return tipoVideo;
                }
            }
            for (String tipo : documentoFormato) {
                if (extencion.equalsIgnoreCase(tipo)) {
                    return tipoDocumento;
                }
            }
            for (String tipo : comprimidoFormato) {
                if (extencion.equalsIgnoreCase(tipo)) {
                    return tipoComprimido;
                }
            }
            for (String tipo : presentacionFormato) {
                if (extencion.equalsIgnoreCase(tipo)) {
                    return tipoPresentacion;
                }
            }
        }
        return tipoOtro;
    }

    public static String seleccionarArchivo() {
        FileDialog fDialog = new FileDialog(new Frame(), "Seleccione un archivo para guardar:");
        fDialog.show();
        String directorio = fDialog.getDirectory();
        String arch = fDialog.getFile();
        if (directorio != null && arch != null) {
            String fileName = directorio + arch;
            return fileName;
        }
        System.exit(0);
        return null;
    }

    public static String guardarComoArchivo(String nombreArchivo) {
        FileDialog fd = new FileDialog(new Frame(), "Guardar como", FileDialog.SAVE);
        fd.setFile(nombreArchivo);
        fd.show();
        String pathArch = "";
        pathArch = fd.getDirectory() + fd.getFile();
        fd.dispose();
        return pathArch;
    }

    /**
     *
     * @param pathFile
     * @return
     * @throws IOException
     */
    public static byte[] getBytesFromFile(String pathFile) throws IOException {
        File file = new File(pathFile);
        InputStream is = new FileInputStream(file);

        // Get the size of the file
        long length = file.length();

        if (length > Integer.MAX_VALUE) {
            // File is too large
        }

        // Create the byte array to hold the data
        byte[] bytes = new byte[(int) length];

        // Read in the bytes
        int offset = 0;
        int numRead = 0;
        while (offset < bytes.length
                && (numRead = is.read(bytes, offset, bytes.length - offset)) >= 0) {
            offset += numRead;
        }

        // Ensure all the bytes have been read in
        if (offset < bytes.length) {
            throw new IOException("Could not completely read file " + file.getName());
        }

        // Close the input stream and return bytes
        is.close();
        return bytes;
    }

    //<editor-fold defaultstate="collapsed" desc="Diferentes formas para descargar un Archivo">
    /**
     * No funciona para guardar imágenes desde la DB
     *
     * @param arch
     */
    public static void guardarArchivo1(String pathArchivo, Archivo arch) {
        try {
            InputStream fotoByteArrayInputStream = new ByteArrayInputStream(arch.getDatosArchivo());
            BufferedImage bImageFromConvert = ImageIO.read(fotoByteArrayInputStream);
            if (bImageFromConvert != null) {
                File file = new File(pathArchivo);
                ImageIO.write(bImageFromConvert, ArchUtils.getExtencionArchivo(pathArchivo), file);
            } else {
                System.out.println("Error al leer datos binarios de la base de datos");
            }
        } catch (IOException ex) {
            System.out.println("Error de escritura");
        }
    }

    /**
     * No funciona para guardar imágenes desde la DB
     *
     * @param arch
     * @throws IOException
     */
    public static void guardarArchivo2(String pathArchivo, Archivo arch) {
        try {
            FileOutputStream out = new FileOutputStream(pathArchivo);
            out.write(arch.getDatosArchivo());
            out.close();
        } catch (IOException ex) {
            System.out.println("Error de escritura");
        }
    }

    /**
     * No funciona para guardar imágenes desde la DB
     *
     * @param arch
     */
    public static void guardarArchivo3(String pathArchivo, Archivo arch) {
        try {
            ByteArrayInputStream bais = new ByteArrayInputStream(arch.getDatosArchivo());
            BufferedImage bImageFromConvert = ImageIO.read(bais);
            if (bImageFromConvert != null) {
                File file = new File(pathArchivo);
                ImageIO.write(bImageFromConvert, ArchUtils.getExtencionArchivo(pathArchivo), file);
            } else {
                System.out.println("Error al leer datos binarios de la base de datos");
            }
        } catch (IOException ex) {
            System.out.println("Error de escritura");
        }
    }

    /**
     * No funciona para guardar imágenes desde la DB
     *
     * @param arch
     * @throws IOException
     */
    public static void guardarArchivo4(String pathCarpeta, Archivo arch) {
        try {
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(pathCarpeta));
            bos.write(arch.getDatosArchivo());
            bos.flush();
            bos.close();
        } catch (IOException ex) {
            System.out.println("Error de escritura");
        }
    }
    //</editor-fold>
}
